home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / x / volume7 / xtiff / patch1 < prev    next >
Encoding:
Text File  |  1990-05-17  |  25.2 KB  |  723 lines
  1. Path: uunet!snorkelwacker!apple!sun-barr!newstop!sun!decpa.pa.dec.com
  2. From: dbs@decpa.pa.dec.com (dan sears)
  3. Newsgroups: comp.sources.x
  4. Subject: v07i054: xtiff, Patch1, Part01/01
  5. Message-ID: <135893@sun.Eng.Sun.COM>
  6. Date: 17 May 90 20:44:27 GMT
  7. Sender: news@sun.Eng.Sun.COM
  8. Lines: 712
  9. Approved: argv@sun.com
  10.  
  11. Submitted-by: dbs@decpa.pa.dec.com (dan sears)
  12. Posting-number: Volume 7, Issue 54
  13. Archive-name: xtiff/patch1
  14. Patch-To: xtiff: Volume 7, Issue 37 (5/12/90)
  15.  
  16. These patches correct a few minor bugs in the original release of xtiff
  17. dealing with different visual types.  The routines CreateXImage() and
  18. GetTIFFImage() are where these problems reside and are resolved.  Basically,
  19. the available documentation does not provide enough information to figure
  20. out the many to many mapping between a complex TIFF image and the numerous
  21. configurations of X visuals.  We would like to write some magic code in
  22. CreateXImage which worked for all cases on all servers but it isn't that
  23. simple.
  24.  
  25. NB: xtiff.c requires libtiff version 2.2, which is currently in beta test.
  26. --Dan Sears
  27.  
  28.  
  29. -- cut here (patch.01) --
  30. diff -r -c rev1/Imakefile rev2/Imakefile
  31. *** rev1/Imakefile    Wed May 16 12:33:35 1990
  32. --- rev2/Imakefile    Thu May 17 11:18:37 1990
  33. ***************
  34. *** 17,28 ****
  35.   AllTarget(xtiff)
  36.   NormalProgramTarget(xtiff, $(OBJS), /* */, $(LOCAL_LIBRARIES), /* */)
  37.   DependTarget()
  38. - 
  39. - proto::
  40. -     cproto $(TIFF_INCLUDES) xtiff.c > xtiff.proto
  41. - 
  42. - lint::
  43. -     lint $(TIFF_INCLUDES) xtiff.c -lX11 -lm
  44. - 
  45. - tags::
  46. -     ctags xtiff.c
  47. --- 17,19 ----
  48. diff -r -c /dev/null rev2/patchlevel.h
  49. *** /dev/null    Wed May 16 23:18:29 1990
  50. --- patchlevel.h    Thu May 17 11:16:26 1990
  51. ***************
  52. *** 0 ****
  53. --- 1 ----
  54. + #define PATCHLEVEL 1
  55. diff -r -c rev1/xtiff.c rev2/xtiff.c
  56. *** rev1/xtiff.c    Wed May 16 12:33:38 1990
  57. --- rev2/xtiff.c    Thu May 17 11:21:23 1990
  58. ***************
  59. *** 1,9 ****
  60.   /*
  61.    * xtiff - view a TIFF file in an X window
  62.    *
  63. !  * Dan Sears - May 7, 1990
  64.    * Chris Sears
  65.    *
  66.    * Copyright 1990 by Digital Equipment Corporation, Maynard, Massachusetts.
  67.    *
  68.    *                        All Rights Reserved
  69. --- 1,14 ----
  70.   /*
  71.    * xtiff - view a TIFF file in an X window
  72.    *
  73. !  * Dan Sears
  74.    * Chris Sears
  75.    *
  76. +  * Revsion 1.1  90/05/16
  77. +  *      Fixed a few minor bugs.
  78. +  * Revsion 1.0  90/05/07
  79. +  *      Initial release.
  80. +  *
  81.    * Copyright 1990 by Digital Equipment Corporation, Maynard, Massachusetts.
  82.    *
  83.    *                        All Rights Reserved
  84. ***************
  85. *** 42,49 ****
  86.    * default TIFF and X orientation.  Other orientations will be
  87.    * displayed incorrectly.
  88.    *
  89. !  * Only TIFFTAG_BITSPERSAMPLE values that are powers of 2 (1, 2, 4 or 8)
  90. !  * are supported.
  91.    */
  92.   
  93.   #include <math.h>
  94. --- 47,56 ----
  95.    * default TIFF and X orientation.  Other orientations will be
  96.    * displayed incorrectly.
  97.    *
  98. !  * There is no support for or use of 3/3/2 DirectColor visuals.
  99. !  * TIFFTAG_MINSAMPLEVALUE and TIFFTAG_MAXSAMPLEVALUE are not supported.
  100. !  *
  101. !  * Only TIFFTAG_BITSPERSAMPLE values that are 1, 2, 4 or 8 are supported.
  102.    */
  103.   
  104.   #include <math.h>
  105. ***************
  106. *** 82,88 ****
  107.   GC                  xWinGc, xBitmapGc;
  108.   XGCValues           xGcValues;
  109.   int                 xScreen, xSyncFlag = False, xImageDepth, xNVisuals,
  110. !                     xPixmapFlag = True;
  111.   char *              xGeometry = NULL, *xDisplayName = NULL;
  112.   XVisualInfo *       xVisualList;
  113.   
  114. --- 89,95 ----
  115.   GC                  xWinGc, xBitmapGc;
  116.   XGCValues           xGcValues;
  117.   int                 xScreen, xSyncFlag = False, xImageDepth, xNVisuals,
  118. !                     xPixmapFlag = True, xRedMask, xGreenMask, xBlueMask;
  119.   char *              xGeometry = NULL, *xDisplayName = NULL;
  120.   XVisualInfo *       xVisualList;
  121.   
  122. ***************
  123. *** 92,99 ****
  124.   TIFF *              tfFile;
  125.   u_short             tfBitsPerSample, tfSamplesPerPixel, tfPlanarConfiguration,
  126.                       tfPhotometricInterpretation, tfGrayResponseUnit,
  127. !                     tfImageDepth, tfImageWidth, tfImageHeight, tfBytesPerRow,
  128. !                     tfFillOrder;
  129.   int                 tfDirectory = 0;
  130.   double              tfUnitMap, tfGrayResponseUnitMap[] = {
  131.                           -1, -10, -100, -1000, -10000, -100000
  132. --- 99,105 ----
  133.   TIFF *              tfFile;
  134.   u_short             tfBitsPerSample, tfSamplesPerPixel, tfPlanarConfiguration,
  135.                       tfPhotometricInterpretation, tfGrayResponseUnit,
  136. !                     tfImageDepth, tfImageWidth, tfImageHeight, tfBytesPerRow;
  137.   int                 tfDirectory = 0;
  138.   double              tfUnitMap, tfGrayResponseUnitMap[] = {
  139.                           -1, -10, -100, -1000, -10000, -100000
  140. ***************
  141. *** 122,129 ****
  142.       programName = argv[0];
  143.   
  144.       if (argc == 1) {
  145. !         fprintf(stderr, "Usage: %s file\n", programName);
  146. !         fprintf(stderr, "options:\n");
  147.           fprintf(stderr, "    [-directory directory]\n");
  148.           fprintf(stderr, "    [-display display]\n");
  149.           fprintf(stderr, "    [-gamma gamma]\n");
  150. --- 128,134 ----
  151.       programName = argv[0];
  152.   
  153.       if (argc == 1) {
  154. !         fprintf(stderr, "Usage: %s file\noptions:\n", programName);
  155.           fprintf(stderr, "    [-directory directory]\n");
  156.           fprintf(stderr, "    [-display display]\n");
  157.           fprintf(stderr, "    [-gamma gamma]\n");
  158. ***************
  159. *** 182,189 ****
  160.       /*
  161.        * If the following tags aren't present then use the TIFF defaults.
  162.        */
  163. -     if (!TIFFGetField(tfFile, TIFFTAG_FILLORDER, &tfFillOrder))
  164. -         tfFillOrder = FILLORDER_MSB2LSB;
  165.       if (!TIFFGetField(tfFile, TIFFTAG_BITSPERSAMPLE, &tfBitsPerSample))
  166.           tfBitsPerSample = 1;
  167.       if (!TIFFGetField(tfFile, TIFFTAG_SAMPLESPERPIXEL, &tfSamplesPerPixel))
  168. --- 187,192 ----
  169. ***************
  170. *** 200,205 ****
  171. --- 203,209 ----
  172.       dRed = (double *) malloc(colormapSize * sizeof(double));
  173.       dGreen = (double *) malloc(colormapSize * sizeof(double));
  174.       dBlue = (double *) malloc(colormapSize * sizeof(double));
  175. +     MCHECK(dRed); MCHECK(dGreen); MCHECK(dBlue);
  176.   
  177.       /*
  178.        * If TIFFTAG_PHOTOMETRIC is not present then assign a reasonable default.
  179. ***************
  180. *** 306,314 ****
  181.   }
  182.   
  183.   /*
  184. !  * Many programs get TIFF colormaps wrong.  They use 8-bit colormaps instead
  185. !  * of 16-bit colormaps.  This function is a heuristic to detect and correct
  186. !  * that problem.
  187.    */
  188.   void
  189.   CheckAndCorrectColormap()
  190. --- 310,317 ----
  191.   }
  192.   
  193.   /*
  194. !  * Many programs get TIFF colormaps wrong.  They use 8-bit colormaps instead of
  195. !  * 16-bit colormaps.  This function is a heuristic to detect and correct this.
  196.    */
  197.   void
  198.   CheckAndCorrectColormap()
  199. ***************
  200. *** 334,348 ****
  201.       register int i;
  202.   
  203.       for (i = 0; i < colormapSize; i++) {
  204. !         if ((tfPhotometricInterpretation == PHOTOMETRIC_MINISWHITE)
  205.               && (i == colormapSize - 1))
  206.               redMap[i] = greenMap[i] = blueMap[i] = 0;
  207. !         else if (i == 0)
  208. !             redMap[i] = greenMap[i] = blueMap[i] = 0;
  209. ! 
  210. !         redMap[i] = ROUND((pow(dRed[i] / 65535.0, 1.0 / dGamma) * 65535.0));
  211. !         greenMap[i] = ROUND((pow(dGreen[i] / 65535.0, 1.0 / dGamma) * 65535.0));
  212. !         blueMap[i] = ROUND((pow(dBlue[i] / 65535.0, 1.0 / dGamma) * 65535.0));
  213.       }
  214.   
  215.       free(dRed); free(dGreen); free(dBlue);
  216. --- 337,352 ----
  217.       register int i;
  218.   
  219.       for (i = 0; i < colormapSize; i++) {
  220. !         if (((tfPhotometricInterpretation == PHOTOMETRIC_MINISWHITE)
  221.               && (i == colormapSize - 1))
  222. +             || ((tfPhotometricInterpretation == PHOTOMETRIC_MINISBLACK)
  223. +             && (i == 0)))
  224.               redMap[i] = greenMap[i] = blueMap[i] = 0;
  225. !         else {
  226. !             redMap[i] = ROUND((pow(dRed[i] / 65535.0, 1.0 / dGamma) * 65535.0));
  227. !             greenMap[i] = ROUND((pow(dGreen[i] / 65535.0, 1.0 / dGamma) * 65535.0));
  228. !             blueMap[i] = ROUND((pow(dBlue[i] / 65535.0, 1.0 / dGamma) * 65535.0));
  229. !         }
  230.       }
  231.   
  232.       free(dRed); free(dGreen); free(dBlue);
  233. ***************
  234. *** 355,361 ****
  235.       char **xargv;
  236.   {
  237.       register int i;
  238. !     int win_x = 0, win_y = 0, win_width, win_height;
  239.       u_int border_width = 3;
  240.       XSizeHints size_hints;
  241.       XSetWindowAttributes window_attributes;
  242. --- 359,365 ----
  243.       char **xargv;
  244.   {
  245.       register int i;
  246. !     int win_x = 0, win_y = 0, win_w = tfImageWidth, win_h = tfImageHeight;
  247.       u_int border_width = 3;
  248.       XSizeHints size_hints;
  249.       XSetWindowAttributes window_attributes;
  250. ***************
  251. *** 368,376 ****
  252.           exit(0);
  253.       }
  254.   
  255. -     xScreen = DefaultScreen(xDisplay);
  256.       XSetErrorHandler(XTiffErrorHandler);
  257.       XSynchronize(xDisplay, xSyncFlag);
  258.   
  259.       if (tfImageDepth != 1) {
  260.           template_visual.screen = xScreen;
  261. --- 372,380 ----
  262.           exit(0);
  263.       }
  264.   
  265.       XSetErrorHandler(XTiffErrorHandler);
  266.       XSynchronize(xDisplay, xSyncFlag);
  267. +     xScreen = DefaultScreen(xDisplay);
  268.   
  269.       if (tfImageDepth != 1) {
  270.           template_visual.screen = xScreen;
  271. ***************
  272. *** 386,392 ****
  273.       switch (tfImageDepth) {
  274.       /*
  275.        * X really wants a 32-bit image with the fourth channel unused,
  276. !      * but the visual structure thinks it's 24-bit.
  277.        */
  278.       case 32:
  279.       case 24:
  280. --- 390,396 ----
  281.       switch (tfImageDepth) {
  282.       /*
  283.        * X really wants a 32-bit image with the fourth channel unused,
  284. !      * but the visual structure thinks it's 24-bit.  bitmap_unit is 32.
  285.        */
  286.       case 32:
  287.       case 24:
  288. ***************
  289. *** 397,402 ****
  290. --- 401,407 ----
  291.           }
  292.   
  293.           colors = (XColor *) malloc(3 * colormapSize * sizeof(XColor));
  294. +         MCHECK(colors);
  295.   
  296.           for (i = 0; i < colormapSize; i++) {
  297.               colors[i].pixel = (u_long) (i << 16) + (i << 8) + i;
  298. ***************
  299. *** 420,431 ****
  300.           switch (tfPhotometricInterpretation) {
  301.           case PHOTOMETRIC_MINISWHITE:
  302.           case PHOTOMETRIC_MINISBLACK:
  303. -             /*
  304. -              * The VAX Firefox is broken here so PseudoColor is searched first.
  305. -              * The GrayScale visual doesn't seem to work.
  306. -              */
  307. -             if (SearchVisualList((int) tfImageDepth, PseudoColor, &xVisual))
  308. -                 break;
  309.               if (SearchVisualList((int) tfImageDepth, GrayScale, &xVisual))
  310.                   break;
  311.           case PHOTOMETRIC_PALETTE:
  312. --- 425,430 ----
  313. ***************
  314. *** 438,443 ****
  315. --- 437,443 ----
  316.           }
  317.   
  318.           colors = (XColor *) malloc(colormapSize * sizeof(XColor));
  319. +         MCHECK(colors);
  320.   
  321.           for (i = 0; i < colormapSize; i++) {
  322.               colors[i].pixel = (u_long) i;
  323. ***************
  324. *** 450,456 ****
  325.           /*
  326.            * xtiff's colormap allocation is private.  It does not attempt
  327.            * to detect whether any existing colormap entries are suitable
  328. !          * for its use.
  329.            */
  330.           xColormap = XCreateColormap(xDisplay, RootWindow(xDisplay, xScreen),
  331.               xVisual, AllocAll);
  332. --- 450,456 ----
  333.           /*
  334.            * xtiff's colormap allocation is private.  It does not attempt
  335.            * to detect whether any existing colormap entries are suitable
  336. !          * for its use.  This causes colormap flashing.
  337.            */
  338.           xColormap = XCreateColormap(xDisplay, RootWindow(xDisplay, xScreen),
  339.               xVisual, AllocAll);
  340. ***************
  341. *** 473,481 ****
  342.       window_attributes.event_mask = ExposureMask | ButtonPressMask;
  343.   
  344.       /*
  345. !      * win_width and win_height are not currently used.
  346.        */
  347. !     XParseGeometry(xGeometry, &win_x, &win_y, &win_width, &win_height);
  348.   
  349.       xWindow = XCreateWindow(xDisplay, RootWindow(xDisplay, xScreen),
  350.           win_x, win_y, tfImageWidth, tfImageHeight, border_width,
  351. --- 473,482 ----
  352.       window_attributes.event_mask = ExposureMask | ButtonPressMask;
  353.   
  354.       /*
  355. !      * win_w and win_h are not currently used.
  356.        */
  357. !     if (xGeometry != NULL)
  358. !         XParseGeometry(xGeometry, &win_x, &win_y, &win_w, &win_h);
  359.   
  360.       xWindow = XCreateWindow(xDisplay, RootWindow(xDisplay, xScreen),
  361.           win_x, win_y, tfImageWidth, tfImageHeight, border_width,
  362. ***************
  363. *** 495,508 ****
  364.           xtifficon_bits, xtifficon_width, xtifficon_height);
  365.   
  366.       size_hints.flags = PPosition | PSize | PMinSize | PMaxSize;
  367. !     size_hints.x = win_x;
  368. !     size_hints.y = win_y;
  369. !     size_hints.width = tfImageWidth;
  370. !     size_hints.height = tfImageHeight;
  371. !     size_hints.min_width = tfImageWidth;
  372. !     size_hints.min_height = tfImageHeight;
  373. !     size_hints.max_width = tfImageWidth;
  374. !     size_hints.max_height = tfImageHeight;
  375.   
  376.       XSetStandardProperties(xDisplay, xWindow, programName, programName,
  377.           xTiffIconPixmap, xargv, xargc, &size_hints);
  378. --- 496,506 ----
  379.           xtifficon_bits, xtifficon_width, xtifficon_height);
  380.   
  381.       size_hints.flags = PPosition | PSize | PMinSize | PMaxSize;
  382. !     size_hints.x = win_x; size_hints.y = win_y;
  383. !     size_hints.width = size_hints.min_width =
  384. !         size_hints.max_width = tfImageWidth;
  385. !     size_hints.height = size_hints.min_height =
  386. !         size_hints.max_height = tfImageHeight;
  387.   
  388.       XSetStandardProperties(xDisplay, xWindow, programName, programName,
  389.           xTiffIconPixmap, xargv, xargc, &size_hints);
  390. ***************
  391. *** 523,530 ****
  392.   
  393.       for (vis = xVisualList, i = 0; i < xNVisuals; vis++, i++) {
  394.           if ((vis->class == visual_class) && (vis->depth >= image_depth)) {
  395.               xImageDepth = vis->depth;
  396. !             xVisual = vis->visual;
  397.               return True;
  398.           }
  399.       }
  400. --- 521,531 ----
  401.   
  402.       for (vis = xVisualList, i = 0; i < xNVisuals; vis++, i++) {
  403.           if ((vis->class == visual_class) && (vis->depth >= image_depth)) {
  404. +             *visual = vis->visual;
  405.               xImageDepth = vis->depth;
  406. !             xRedMask = vis->red_mask;
  407. !             xGreenMask = vis->green_mask;
  408. !             xBlueMask = vis->blue_mask;
  409.               return True;
  410.           }
  411.       }
  412. ***************
  413. *** 535,542 ****
  414.   void
  415.   GetTIFFImage()
  416.   {
  417.       register int i, j, s;
  418. !     register u_char *scan_line, *output_p, *input_p, p;
  419.   
  420.       tfBytesPerRow = TIFFScanlineSize(tfFile);
  421.       scan_line = (u_char *) malloc(tfBytesPerRow);
  422. --- 536,544 ----
  423.   void
  424.   GetTIFFImage()
  425.   {
  426. +     register u_char *scan_line, *output_p, *input_p;
  427.       register int i, j, s;
  428. !     int pixel_map[3], red_shift, green_shift, blue_shift;
  429.   
  430.       tfBytesPerRow = TIFFScanlineSize(tfFile);
  431.       scan_line = (u_char *) malloc(tfBytesPerRow);
  432. ***************
  433. *** 543,561 ****
  434.       MCHECK(scan_line);
  435.   
  436.       if ((tfImageDepth == 32) || (tfImageDepth == 24)) {
  437. !         output_p = imageMemory =
  438. !             (u_char *) malloc(tfImageWidth * tfImageHeight * 4);
  439.           MCHECK(imageMemory);
  440.   
  441.           if (tfPlanarConfiguration == PLANARCONFIG_CONTIG) {
  442.               for (i = 0; i < tfImageHeight; i++) {
  443.                   if (TIFFReadScanline(tfFile, scan_line, i, 0) < 0)
  444.                       break;
  445.                   for (input_p = scan_line, j = 0; j < tfImageWidth; j++) {
  446. !                     *output_p++ = *input_p++;
  447. !                     *output_p++ = *input_p++;
  448. !                     *output_p++ = *input_p++;
  449. !                     output_p++;
  450.                       if (tfSamplesPerPixel == 4) /* skip the fourth channel */
  451.                           input_p++;
  452.                   }
  453. --- 545,573 ----
  454.       MCHECK(scan_line);
  455.   
  456.       if ((tfImageDepth == 32) || (tfImageDepth == 24)) {
  457. !         output_p = imageMemory = (u_char *)
  458. !             malloc(tfImageWidth * tfImageHeight * 4);
  459.           MCHECK(imageMemory);
  460.   
  461. +         /*
  462. +          * Handle different color masks for different frame buffers.
  463. +          */
  464. +         red_shift = pixel_map[0] = xRedMask == 0xFF000000 ? 3
  465. +             : (xRedMask == 0xFF0000 ? 2 : (xRedMask == 0xFF00 ? 1 : 0));
  466. +         green_shift = pixel_map[1] = xGreenMask == 0xFF000000 ? 3
  467. +             : (xGreenMask == 0xFF0000 ? 2 : (xGreenMask == 0xFF00 ? 1 : 0));
  468. +         blue_shift = pixel_map[2] = xBlueMask == 0xFF000000 ? 3
  469. +             : (xBlueMask == 0xFF0000 ? 2 : (xBlueMask == 0xFF00 ? 1 : 0));
  470. + 
  471.           if (tfPlanarConfiguration == PLANARCONFIG_CONTIG) {
  472.               for (i = 0; i < tfImageHeight; i++) {
  473.                   if (TIFFReadScanline(tfFile, scan_line, i, 0) < 0)
  474.                       break;
  475.                   for (input_p = scan_line, j = 0; j < tfImageWidth; j++) {
  476. !                     *(output_p + red_shift) = *input_p++;
  477. !                     *(output_p + green_shift) = *input_p++;
  478. !                     *(output_p + blue_shift) = *input_p++;
  479. !                     output_p += 4;
  480.                       if (tfSamplesPerPixel == 4) /* skip the fourth channel */
  481.                           input_p++;
  482.                   }
  483. ***************
  484. *** 568,574 ****
  485.                       if (TIFFReadScanline(tfFile, scan_line, i, s) < 0)
  486.                           break;
  487.                       input_p = scan_line;
  488. !                     output_p = imageMemory + (i * tfImageWidth * 4) + s;
  489.                       for (j = 0; j < tfImageWidth; j++, output_p += 4)
  490.                           *output_p = *input_p++;
  491.                   }
  492. --- 580,586 ----
  493.                       if (TIFFReadScanline(tfFile, scan_line, i, s) < 0)
  494.                           break;
  495.                       input_p = scan_line;
  496. !                     output_p = imageMemory + (i*tfImageWidth*4) + pixel_map[s];
  497.                       for (j = 0; j < tfImageWidth; j++, output_p += 4)
  498.                           *output_p = *input_p++;
  499.                   }
  500. ***************
  501. *** 581,588 ****
  502.            */
  503.           if ((tfPhotometricInterpretation == PHOTOMETRIC_MINISWHITE)
  504.               && (tfImageDepth == 1)) {
  505. !             output_p = imageMemory =
  506. !                 (u_char *) malloc(tfBytesPerRow * tfImageHeight);
  507.               MCHECK(imageMemory);
  508.   
  509.               for (i = 0; i < tfImageHeight; i++, output_p += tfBytesPerRow) {
  510. --- 593,600 ----
  511.            */
  512.           if ((tfPhotometricInterpretation == PHOTOMETRIC_MINISWHITE)
  513.               && (tfImageDepth == 1)) {
  514. !             output_p = imageMemory = (u_char *)
  515. !                 malloc(tfBytesPerRow * tfImageHeight);
  516.               MCHECK(imageMemory);
  517.   
  518.               for (i = 0; i < tfImageHeight; i++, output_p += tfBytesPerRow) {
  519. ***************
  520. *** 593,600 ****
  521.                       *input_p = ~ *input_p;
  522.               }
  523.           } else if (xImageDepth == tfImageDepth) {
  524. !             output_p = imageMemory =
  525. !                 (u_char *) malloc(tfBytesPerRow * tfImageHeight);
  526.               MCHECK(imageMemory);
  527.   
  528.               for (i = 0; i < tfImageHeight; i++, output_p += tfBytesPerRow)
  529. --- 605,612 ----
  530.                       *input_p = ~ *input_p;
  531.               }
  532.           } else if (xImageDepth == tfImageDepth) {
  533. !             output_p = imageMemory = (u_char *)
  534. !                 malloc(tfBytesPerRow * tfImageHeight);
  535.               MCHECK(imageMemory);
  536.   
  537.               for (i = 0; i < tfImageHeight; i++, output_p += tfBytesPerRow)
  538. ***************
  539. *** 601,608 ****
  540.                   if (TIFFReadScanline(tfFile, output_p, i, 0) < 0)
  541.                       break;
  542.           } else if ((xImageDepth == 8) && (tfImageDepth == 4)) {
  543. !             output_p = imageMemory =
  544. !                 (u_char *) malloc(tfBytesPerRow * 2 * tfImageHeight + 2);
  545.               MCHECK(imageMemory);
  546.   
  547.               /*
  548. --- 613,620 ----
  549.                   if (TIFFReadScanline(tfFile, output_p, i, 0) < 0)
  550.                       break;
  551.           } else if ((xImageDepth == 8) && (tfImageDepth == 4)) {
  552. !             output_p = imageMemory = (u_char *)
  553. !                 malloc(tfBytesPerRow * 2 * tfImageHeight + 2);
  554.               MCHECK(imageMemory);
  555.   
  556.               /*
  557. ***************
  558. *** 616,628 ****
  559.                   output_p = &imageMemory[i * tfImageWidth];
  560.                   input_p = scan_line;
  561.                   for (j = 0; j < tfImageWidth; j += 2, input_p++) {
  562. !                     *output_p++ = (*input_p) >> 4;
  563. !                     *output_p++ = (*input_p) & 0xf;
  564.                   }
  565.               }
  566.           } else if ((xImageDepth == 8) && (tfImageDepth == 2)) {
  567. !             output_p = imageMemory =
  568. !                 (u_char *) malloc(tfBytesPerRow * 4 * tfImageHeight + 4);
  569.               MCHECK(imageMemory);
  570.   
  571.               for (i = 0; i < tfImageHeight; i++) {
  572. --- 628,640 ----
  573.                   output_p = &imageMemory[i * tfImageWidth];
  574.                   input_p = scan_line;
  575.                   for (j = 0; j < tfImageWidth; j += 2, input_p++) {
  576. !                     *output_p++ = *input_p >> 4;
  577. !                     *output_p++ = *input_p & 0xf;
  578.                   }
  579.               }
  580.           } else if ((xImageDepth == 8) && (tfImageDepth == 2)) {
  581. !             output_p = imageMemory = (u_char *)
  582. !                 malloc(tfBytesPerRow * 4 * tfImageHeight + 4);
  583.               MCHECK(imageMemory);
  584.   
  585.               for (i = 0; i < tfImageHeight; i++) {
  586. ***************
  587. *** 638,645 ****
  588.                   }
  589.               }
  590.           } else if ((xImageDepth == 4) && (tfImageDepth == 2)) {
  591. !             output_p = imageMemory =
  592. !                 (u_char *) malloc(tfBytesPerRow * 2 * tfImageHeight + 2);
  593.               MCHECK(imageMemory);
  594.   
  595.               for (i = 0; i < tfImageHeight; i++) {
  596. --- 650,657 ----
  597.                   }
  598.               }
  599.           } else if ((xImageDepth == 4) && (tfImageDepth == 2)) {
  600. !             output_p = imageMemory = (u_char *)
  601. !                 malloc(tfBytesPerRow * 2 * tfImageHeight + 2);
  602.               MCHECK(imageMemory);
  603.   
  604.               for (i = 0; i < tfImageHeight; i++) {
  605. ***************
  606. *** 648,655 ****
  607.                   output_p = &imageMemory[i * tfImageWidth];
  608.                   input_p = scan_line;
  609.                   for (j = 0; j < tfImageWidth; j += 4, input_p++) {
  610. !                     *output_p++ = ((*input_p >> 6) << 4) | (*input_p >> 4) & 3;
  611. !                     *output_p++ = (((*input_p >> 2) & 3) << 4) | *input_p & 3;
  612.                   }
  613.               }
  614.           } else {
  615. --- 660,667 ----
  616.                   output_p = &imageMemory[i * tfImageWidth];
  617.                   input_p = scan_line;
  618.                   for (j = 0; j < tfImageWidth; j += 4, input_p++) {
  619. !                     *output_p++ = ((*input_p>>6) << 4) | ((*input_p >> 4) & 3);
  620. !                     *output_p++ = (((*input_p>>2) & 3) << 4) | (*input_p & 3);
  621.                   }
  622.               }
  623.           } else {
  624. ***************
  625. *** 677,704 ****
  626.       /*
  627.        * libtiff converts LSB data into MSB but doesn't change the FillOrder tag.
  628.        */
  629. !     xImage->bitmap_bit_order = MSBFirst;
  630. ! 
  631.       if (xImageDepth <= 8)
  632.           xImage->byte_order = MSBFirst;
  633. -     else
  634. -         xImage->byte_order = xVisual->red_mask > xVisual->blue_mask
  635. -             ? LSBFirst : MSBFirst;
  636.   
  637. -     /*
  638. -      * According to the O'Reilly X Protocol Reference Manual, page 53,
  639. -      * "A pixmap depth of one is always supported and listed, but windows
  640. -      * of depth one might not be supported."  Therefore we create a pixmap
  641. -      * of depth one and use XCopyPlane().
  642. -      */
  643.       if (xPixmapFlag == True) {
  644.           xImagePixmap = XCreatePixmap(xDisplay, RootWindow(xDisplay, xScreen),
  645.               xImage->width, xImage->height, xImageDepth);
  646.   
  647.           if (xImageDepth == 1) {
  648. !             xBitmapGc = XCreateGC(xDisplay, xImagePixmap,
  649. !                 GCFunction | GCPlaneMask | GCForeground | GCBackground,
  650. !                 &xGcValues);
  651.               XPutImage(xDisplay, xImagePixmap, xBitmapGc, xImage,
  652.                   0, 0, 0, 0, xImage->width, xImage->height);
  653.           } else
  654. --- 689,712 ----
  655.       /*
  656.        * libtiff converts LSB data into MSB but doesn't change the FillOrder tag.
  657.        */
  658. !     if (xImageDepth == 1)
  659. !         xImage->bitmap_bit_order = MSBFirst;
  660.       if (xImageDepth <= 8)
  661.           xImage->byte_order = MSBFirst;
  662.   
  663.       if (xPixmapFlag == True) {
  664.           xImagePixmap = XCreatePixmap(xDisplay, RootWindow(xDisplay, xScreen),
  665.               xImage->width, xImage->height, xImageDepth);
  666.   
  667. +         /*
  668. +          * According to the O'Reilly X Protocol Reference Manual, page 53,
  669. +          * "A pixmap depth of one is always supported and listed, but windows
  670. +          * of depth one might not be supported."  Therefore we create a pixmap
  671. +          * of depth one and use XCopyPlane().  This is idiomatic.
  672. +          */
  673.           if (xImageDepth == 1) {
  674. !             xBitmapGc = XCreateGC(xDisplay, xImagePixmap, GCFunction
  675. !                 | GCPlaneMask | GCForeground | GCBackground, &xGcValues);
  676.               XPutImage(xDisplay, xImagePixmap, xBitmapGc, xImage,
  677.                   0, 0, 0, 0, xImage->width, xImage->height);
  678.           } else
  679. ***************
  680. *** 706,714 ****
  681.                   0, 0, 0, 0, xImage->width, xImage->height);
  682.           XDestroyImage(xImage);
  683.       }
  684. - 
  685. -     if (xPixmapFlag == True)
  686. -         free(imageMemory);
  687.   
  688.       if (grayMap != NULL)
  689.           free(grayMap);
  690. --- 714,719 ----
  691. diff -r -c rev1/xtiff.man rev2/xtiff.man
  692. *** rev1/xtiff.man    Wed May 16 12:33:39 1990
  693. --- rev2/xtiff.man    Thu May 17 11:16:27 1990
  694. ***************
  695. *** 24,30 ****
  696.   .IR file
  697.   .SH DESCRIPTION
  698.   .IR xtiff
  699. ! is a TIFF viewer for X-based on the
  700.   .IR libtiff (3)
  701.   package.
  702.   It displays a single TIFF file in an X window
  703. --- 24,30 ----
  704.   .IR file
  705.   .SH DESCRIPTION
  706.   .IR xtiff
  707. ! is a TIFF viewer for X based on the
  708.   .IR libtiff (3)
  709.   package.
  710.   It displays a single TIFF file in an X window
  711. ***************
  712. *** 162,164 ****
  713. --- 162,165 ----
  714.   or
  715.   .IR TrueColor
  716.   visuals except for 1-bit images.
  717. + There is no support for 3/3/2 DirectColor visuals.
  718.  
  719. dan
  720. ----------------------------------------------------
  721. O'Reilly && Associates   argv@sun.com / argv@ora.com
  722. Opinions expressed reflect those of the author only.
  723.